Hoe verander ik bestaande, niet-gepushte vastlegberichten?

Het meest recente vastleggingsbericht wijzigen
git commit --amend
zal je editor openen, waardoor je het vastlegbericht van de meest recente vastlegging kunt wijzigen. Bovendien kunt u het vastlegbericht rechtstreeks op de opdrachtregel instellen met:
git commit --amend -m "Nieuw vastleggingsbericht"
… Dit kan echter vastleggingsberichten met meerdere regels of kleine correcties lastiger maken om in te voeren.
Zorg ervoor dat je geen wijzigingen in de werkkopie hebt uitgevoerd voordat je dit doet, anders worden ze ook vastgelegd. (Niet-getrapte wijzigingen worden niet vastgelegd.)
Het bericht veranderen van een commit die je al naar je remote branch hebt gepusht
Als je je commit al naar je remote branch hebt gepusht, dan moet je - na het lokaal wijzigen van je commit (zoals hierboven beschreven) - ook de commit forceren met:
git push   --force
# Of
git push   -f
Waarschuwing: geforceerd pushen zal de remote branch overschrijven met de staat van je lokale. Als er commits zijn op de remote branch die je niet hebt in je lokale branch, verlies je die commits.
Waarschuwing: wees voorzichtig met het wijzigen van commits die je al hebt gedeeld met andere mensen. Het aanpassen van commits herschrijft ze in wezen om verschillende SHA ID's te hebben, wat een probleem vormt als andere mensen kopieën hebben van de oude commit die je herschreven hebt. Iedereen die een kopie van de oude commit heeft, zal zijn werk moeten synchroniseren met je nieuw herschreven commit, wat soms moeilijk kan zijn, dus zorg ervoor dat je samenwerkt met anderen wanneer je de gedeelde commit-geschiedenis probeert te herschrijven, of vermijd gewoon het herschrijven van gedeelde commits allemaal samen.
Voer een interactieve rebase uit
Een andere optie is om interactieve rebase te gebruiken.
Hiermee kunt u elk bericht dat u wilt bijwerken bewerken, zelfs als het niet het laatste bericht is.
Volg deze stappen om een ​​Git-squash te doen:
// n is het aantal commits tot aan de laatste commit die je wilt kunnen bewerken
git rebase -i HEAD ~ n
Zodra je je commits hebt geplet, kies je de e / r voor het bewerken van het bericht:
Belangrijke opmerking over interactieve rebase
Als je git rebase -i HEAD ~ n gebruikt, kunnen er meer dan n commits zijn. Git zal alle commits in de laatste n commits "verzamelen", en als er ergens tussen die range een merge was, zul je ook alle commits zien, dus het resultaat zal n + zijn.
Goed advies:
Als je het voor meer dan een enkele branch moet doen en je zou met conflicten te maken kunnen krijgen bij het wijzigen van de inhoud, stel git rerere in en laat Git die conflicten automatisch voor je oplossen.
Documentatie
git-commit (1) handmatige pagina
git-rebase (1) handmatige pagina
git-push (1) handmatige pagina
|
git commit --amend -m "jouw nieuwe bericht"
|
Als de commit die je wilt herstellen niet de meest recente is:
git rebase --interactive $ parent_of_flawed_commit
Als je meerdere foutieve commits wilt herstellen, geef dan de ouder van de oudste van hen door.
Er komt een editor met een lijst met alle commits sinds degene die je hebt gegeven.
Verander de keuze in herformulering (of in oude versies van Git, om te bewerken) voor alle commits die je wilt repareren.
Als je eenmaal hebt opgeslagen, zal Git de vermelde commits opnieuw afspelen.
Voor elke commit die je opnieuw wilt formuleren, zal Git je terugzetten in je editor. Voor elke commit die je wilt bewerken, zet Git je in de shell. Als je in de shell zit:
Verander de commit op elke gewenste manier.
git commit --amend
git rebase --continue
Het grootste deel van deze reeks wordt u uitgelegd door de uitvoer van de verschillende opdrachten terwijl u bezig bent. Het is erg makkelijk; je hoeft het niet te onthouden - onthoud gewoon dat git rebase --interactive je commits laat corrigeren, ongeacht hoe lang geleden ze waren.
Merk op dat je commits die je al hebt gepusht niet wilt wijzigen. Of misschien wel, maar in dat geval moet je goed opletten om te communiceren met iedereen die je commits heeft gehaald en er werk aan heeft gedaan. Hoe herstel / hersynchroniseer ik nadat iemand een rebase of een reset naar een gepubliceerde vertakking pusht?
|
Om de vorige vastlegging te wijzigen, brengt u de gewenste wijzigingen aan, voert u deze wijzigingen in en voert u vervolgens uit
git commit --amend
Dit opent een bestand in je teksteditor dat je nieuwe vastleggingsbericht vertegenwoordigt. Het begint met de tekst van je oude vastleggingsbericht. Verander het vastlegbericht zoals je wilt, sla het bestand op en verlaat je editor om te voltooien.
Om de vorige commit te wijzigen en hetzelfde logbericht te behouden, voer je uit
git commit --amend -C HEAD
Om de vorige commit te herstellen door deze volledig te verwijderen, voer je uit
git reset --hard HEAD ^
Als je meer dan één vastleggingsbericht wilt bewerken, voer je uit
git rebase -i HEAD ~ commit_count
(Vervang commit_count door het aantal commits dat je wilt bewerken.) Dit commando start je editor. Markeer de eerste commit (degene die je wilt veranderen) als "edit" in plaats van "pick", sla dan op en verlaat je editor. Breng de wijziging aan die u wilt vastleggen en voer deze vervolgens uit
git commit --amend
git rebase --continue
Opmerking: je kunt ook "de gewenste wijziging aanbrengen" in de editor die wordt geopend door git commit --amend
|
Zoals reedsgenoemd, git commit --amend is de manier om de laatste commit te overschrijven. Een opmerking: als u ook de bestanden wilt overschrijven, zou het commando zijn
git commit -a --amend -m "Mijn nieuwe commit bericht"
|
Je kunt daarvoor ook git filter-branch gebruiken.
git filter-branch -f --msg-filter "sed 's / errror / error /'" $ flawed_commit..HEAD
Het is niet zo eenvoudig als een triviale git commit --amend, maar het is vooral handig als je al enkele merges hebt na je foutieve commit-bericht.
Merk op dat dit zal proberen om elke commit tussen HEAD en de gebrekkige commit te herschrijven, dus je moet je msg-filter commando heel verstandig kiezen ;-)
|
Ik geef de voorkeur aan deze manier:
git commit --amend -c 
Anders zal er een nieuwe commit zijn met een nieuwe commit ID.
|
Als je de Git GUI-tool gebruikt, is er een knop met de naam Laatste commit wijzigen. Klik op die knop en het zal je laatste vastleggingsbestanden en bericht tonen. Bewerk gewoon dat bericht, en je kunt het vastleggen met een nieuw vastleggingsbericht.
Of gebruik deze opdracht vanaf een console / terminal:
git commit -a --amend -m "Mijn nieuwe commit bericht"
|
Je kunt Git-rebasen gebruiken. Als je bijvoorbeeld terug wilt wijzigen om bbc643cd vast te leggen, voer je uit
$ git rebase bbc643cd ^ --interactief
Wijzig in de standaardeditor 'pick' in 'edit' in de regel waarvan je de commit wilt wijzigen. Breng uw wijzigingen aan en ensceneer ze vervolgens met
$ git add 
Nu kunt u gebruiken
$ git commit --amend
om de commit te wijzigen, en daarna
$ git rebase --continue
om terug te keren naar de vorige head commit.
|
Als je alleen je laatste vastleggingsbericht wilt wijzigen, doe dan:
git commit --amend
Dat zal je naar je teksteditor brengen en je het laatste vastleggingsbericht laten wijzigen.
Als je de laatste drie vastlegberichten wilt wijzigen, of een van de vastlegberichten tot dan toe, geef dan HEAD ~ 3 aan het git rebase -i commando:
git rebase -i HEAD ~ 3
|
Als je een oud commit-bericht over meerdere branches moet wijzigen (d.w.z. de commit met het foutieve bericht is aanwezig in meerdere branches), dan wil je misschien gebruiken:
git filter-branch -f --msg-filter \
'sed "s /  /  / g"' - --all
Git zal een tijdelijke map aanmaken om te herschrijven en bovendien een back-up maken van oude referenties in refs / original /.
-f zal de uitvoering van de operatie afdwingen. Dit is nodig als de tijdelijke directory al aanwezig is of als er al referenties zijn opgeslagen onder refs / original. Als dat niet het geval is, kunt u deze vlag laten vallen.
- scheidt filtertak-opties van revisie-opties.
--all zorgt ervoor dat alle branches en tags worden herschreven.
Door de back-up van uw oude referenties, kunt u gemakkelijk teruggaan naar de staat voordat u de opdracht uitvoert.
Stel dat u uw master wilt herstellen en deze wilt openen in branch old_master:
git checkout -b old_master refs / original / refs / heads / master
|
Gebruik
git commit --amend
Om het in detail te begrijpen, is een uitstekende post 4. Herschrijven van Git-geschiedenis. Het vertelt ook wanneer git commit --amend niet moet worden gebruikt.
|
Als het je laatste commit is, pas dan gewoon de commit aan:
git commit --amend -o -m "Nieuw vastlegbericht"
(Gebruik de -o (--only) vlag om ervoor te zorgen dat je alleen het vastlegbericht verandert)
Als het een begraven commit is, gebruik dan de geweldige interactieve rebase:
git rebase -i @ ~ 9 # Toon de laatste 9 commits in een teksteditor
Zoek de gewenste commit, verander pick in r (reword), en sla het bestand op en sluit het. Gedaan!
Miniatuur Vim-zelfstudie (of, hoe rebasen met slechts 8 toetsaanslagen 3jcwrEscZZ):
Voer vimtutor uit als u tijd heeft
hjkl komen overeen met bewegingstoetsen ← ↓ ↑ →
Alle opdrachten kunnen worden voorafgegaan door een "bereik", bijv. 3j gaat drie regels omlaag
i om de invoegmodus te openen - de tekst die u typt, verschijnt in het bestand
Esc of Ctrlc om de invoegmodus te verlaten en terug te keren naar de "normale" modus
u ongedaan maken
Ctrlr om opnieuw uit te voeren
dd, dw, dl om respectievelijk een regel, woord of letter te verwijderen
cc, cw, cl om respectievelijk een regel, woord of letter te wijzigen (hetzelfde als ddi)
yy, yw, yl om respectievelijk een regel, woord of letter te kopiëren ("rukken")
p of P om respectievelijk na of vóór de huidige positie te plakken
: wEnter om een ​​bestand op te slaan (te schrijven)
: q! Enter om af te sluiten zonder op te slaan
: wqEnter of ZZ om op te slaan en af ​​te sluiten
Als je veel tekst bewerkt, schakel dan over naar de Dvorak-toetsenbordindeling, leer touch-typen en leer Vim. Is het de moeite waard? Ja.
ProTip ™: Wees niet bang om te experimenteren met "gevaarlijke" commando's die de geschiedenis herschrijven * - Git verwijdert je commits niet standaard gedurende 90 dagen; je vindt ze in de reflog:
$ git reset @ ~ 3 # Ga drie commits terug
$ git reflog
c4f708b HEAD @ {0}: reset: verhuizen naar @ ~ 3
2c52489 HEAD @ {1}: commit: meer wijzigingen
4a5246d HEAD @ {2}: commit: breng belangrijke wijzigingen aan
e8571e4 HEAD @ {3}: commit: breng enkele wijzigingen aan
... eerdere commits ...
$ git reset 2c52489
... en je bent terug waar je begon
* Pas op voor opties zoals - echter - hard en - forceren - ze kunnen gegevens weggooien.
* Herschrijf ook de geschiedenis niet op alle branches waaraan u samenwerkt.
|
Wijzigen
Je hebt er een paaropties hier. U kunt doen
git commit --amend
zolang het je laatste commit is.
Interactieve rebase
Anders, als het niet je laatste commit is, kun je een interactieve rebase doen,
git rebase -i [branched_from] [hash voor vastleggen]
Vervolgens voeg je binnen de interactieve rebase eenvoudig een bewerking toe aan die commit. Als het verschijnt, doe dan een git commit --amend en wijzig het vastlegbericht. Als je terug wilt draaien voor dat commit-punt, zou je ook git reflog kunnen gebruiken en die commit gewoon verwijderen. Dan doe je gewoon opnieuw een git commit.
|
Als je de Git GUI gebruikt, kun je de laatste commit wijzigen die niet gepusht is met:
Vastleggen / wijzigen van laatste vastlegging
|
Ik gebruik de Git GUI zo veel als ik kan, en dat geeft je de mogelijkheid om de laatste commit te wijzigen:
Ook is git rebase -i origin / master een mooie mantra die je altijd de commits zal presenteren die je bovenop master hebt gedaan, en je de optie geeft om te wijzigen, verwijderen, opnieuw te ordenen of te squashen. Je hoeft die hasj niet eerst te bemachtigen.
|
Wauw, er zijn dus veel manieren om dit te doen.
Nog een andere manier om dit te doen is door de laatste commit te verwijderen, maar de wijzigingen ervan te behouden zodat je je werk niet verliest. Je kunt dan nog een commit doen met het gecorrigeerde bericht. Dit zou er ongeveer zo uitzien:
git reset --soft HEAD ~ 1
git commit -m 'Nieuw en gecorrigeerd vastleggingsbericht'
Ik doe dit altijd als ik vergeet een bestand toe te voegen of een wijziging door te voeren.
Denk eraan om --soft in plaats van --hard te specificeren, anders verlies je die commit volledig.
|
Voor iedereen die op zoek is naar een Windows / Mac GUI om te helpen bij het bewerken van oudere berichten (dus niet alleen het laatste bericht), zou ik Sourcetree aanraden. De te volgen stappen staan ​​onder de afbeelding.
Voor commits die nog niet naar een remote zijn gepusht:
Zorg ervoor dat u alle huidige wijzigingen heeft vastgelegd of opgeslagen (er staan ​​dus geen bestanden op het tabblad "Bestandsstatus") - anders werkt het niet.
In het "Log / Geschiedenis" tabblad, klik met de rechtermuisknop op het item met een aangrenzende regel in de grafiek onder de commit (s) die je wilt bewerken en selecteer "Rebase kinderen van  interactief ..."
Selecteer de hele rij voor een vastlegbericht dat u wilt wijzigen (klik op de kolom "Bericht").
Klik op de knop "Bericht bewerken".
Bewerk het bericht zoals gewenst in het dialoogvenster dat verschijnt en klik vervolgens op OK.
Herhaal stap 3-4 als er andere vastleggingsberichten zijn die moeten worden gewijzigd.
Klik op OK: het rebasen begint. Als alles goed is, eindigt de uitvoer met "Succesvol voltooid". OPMERKING: ik heb dit wel eens zien mislukken met Unable to create 'project_path / .git / index.lock': Bestand bestaat. wanneer je probeert om meerdere vastleggingsberichten tegelijkertijd te wijzigen. Weet niet precies wat het probleem is, en of het zal worden opgelost in een toekomstige versie van Sourcetree, maar als dit gebeurt, zou ik aanraden om ze een voor een te rebasen (langzamer maar lijkt betrouwbaarder).
... of ... voor commits die al gepusht zijn:
Volg de stappen in dit antwoord, die vergelijkbaar zijn met hierboven, maar er moet nog een commando worden uitgevoerd vanaf de opdrachtregel (git push origin  -f) om de branch geforceerd te pushen. Ik raad u aan alles te lezen en de nodige voorzichtigheid te betrachten!
|
Als je alleen de laatste commit wilt bewerken, gebruik dan:
git commit --amend
of
git commit --amend -m 'een regel bericht'
Maar als je meerdere commits achter elkaar wilt bewerken, zou je in plaats daarvan rebasen moeten gebruiken:
git rebase -i 
Schrijf in een bestand, zoals hierboven, edit / e of een van de andere opties, en klik op opslaan en afsluiten.
Nu zit je bij de eerste verkeerde commit. Breng wijzigingen aan in de bestanden, en ze worden automatisch voor u gearchiveerd. Type
git commit --amend
Bewaar en sluit af en typ
git rebase --continue
om naar de volgende selectie te gaan totdat u klaar bent met al uw selecties.
Merk op dat deze dingen al je SHA-hashes veranderen na die specifieke commit.
|
Als je alleen je laatste bericht wilt veranderen, moet je de --only vlag of zijn snelkoppeling -o met commit --amend gebruiken:
git commit --amend -o -m "Nieuw vastlegbericht"
Dit zorgt ervoor dat je je commit niet per ongeluk verbetert met geënsceneerde dingen. Het is natuurlijk het beste om een ​​goede $ EDITOR-configuratie te hebben. Dan kun je de -m optie weglaten, en Git zal het vastlegbericht vooraf invullen met het oude. Op deze manier kan het gemakkelijk worden bewerkt.
|
Update je laatste verkeerde commit-bericht met het nieuwe commit-bericht op één regel:
git commit --amend -m "je nieuwe commit bericht"
Of probeer Git reset zoals hieronder:
# Je kunt je hoofd resetten naar n aantal vastleggingen
# GEEN goed idee om het laatste vastleggingsbericht te wijzigen,
# maar je kunt een idee krijgen om commit op te splitsen in meerdere commits
git reset --soft HEAD ^
# Het zal je laatste commit resetten. Nu jij
# kan het opnieuw vastleggen met een nieuw vastleggingsbericht.
Reset gebruiken om commits te splitsen in kleinere commits
git reset kan je helpen om een ​​commit ook op te splitsen in meerdere commits:
# Reset je hoofd. Ik reset naar de laatste commits:
git reset --soft HEAD ^
# (Je kunt meerdere commit resetten door HEAD ~ 2 (aantal commits) te doen
# Nu, reset je hoofd voorsplitsen in meerdere commits
git reset HEAD
# Voeg uw bestanden afzonderlijk toe en leg ze vast om meerdere commits te maken: bijv
git add app /
git commit -m "voeg alle bestanden toe in de app-map"
git add config /
git commit -m "voeg alle bestanden toe in de configuratiemap"
Hier heb je met succes je laatste commit opgesplitst in twee commits.
|
Er zijn veel antwoorden op deze vraag, maar geen enkele legt in super detail uit hoe je oudere commit-berichten kunt wijzigen met Vim. Ik zat vast terwijl ik dit zelf probeerde te doen, dus hier zal ik in detail beschrijven hoe ik dit deed, vooral voor mensen die geen ervaring hebben met Vim!
Ik wilde mijn vijf laatste commits wijzigen die ik al naar de server had gepusht. Dit is nogal 'gevaarlijk', want als iemand anders hier al aan heeft getrokken, kun je dingen verknoeien door de vastlegberichten te wijzigen. Als je echter aan je eigen kleine tak werkt en er zeker van bent dat niemand eraan heeft getrokken, kun je dit als volgt wijzigen:
Stel dat je je laatste vijf commits wilt wijzigen, en dan typ je dit in de terminal:
git rebase -i HEAD ~ 5
* Waar 5 het aantal vastlegberichten is dat u wilt wijzigen (dus als u de 10e naar de laatste vastlegging wilt wijzigen, typt u 10).
Dit commando brengt je naar Vim, waar je je vastleggeschiedenis kunt 'bewerken'. Je ziet je laatste vijf commits bovenaan als volgt:
kies  commit bericht
In plaats van te kiezen, moet u herwoord schrijven. Je kunt dit in Vim doen door i in te typen. Dat zorgt ervoor dat je naar de invoegmodus gaat. (Je ziet dat je in de invoegmodus bent door het woord INSERT onderaan.) Voor de commits die je wilt wijzigen, typ je herwoord in plaats van pick.
Vervolgens moet u dit scherm opslaan en afsluiten. Dat doe je door eerst naar ‘command-mode’ te gaan door op de Esc-knop te drukken (je kunt controleren of je in command-mode bent als het woord INSERT onderaan is verdwenen). Vervolgens kunt u een commando typen door te typen:. Het commando om op te slaan en af ​​te sluiten is wq. Dus als je typt: wq ben je op de goede weg.
Dan zal Vim elk vastlegbericht bespreken dat je opnieuw wilt formuleren, en hier kun je de vastlegberichten daadwerkelijk wijzigen. Je doet dit door naar de invoegmodus te gaan, het vastlegbericht te wijzigen, naar de commandomodus te gaan en op te slaan en te stoppen. Doe dit vijf keer en je hebt geen Vim meer!
Als je dan al je verkeerde commits hebt gepusht, moet je git push --force om ze te overschrijven. Onthoud dat git push --force nogal gevaarlijk is om te doen, dus zorg ervoor dat niemand van de server trok sinds je je verkeerde commits hebt gepusht!
Nu heb je je vastleggingsberichten gewijzigd!
(Zoals je ziet, ben ik niet zo ervaren in Vim, dus als ik het verkeerde 'jargon' heb gebruikt om uit te leggen wat er gebeurt, voel je dan vrij om me te corrigeren!)
|
Je kunt git-rebase-reword gebruiken
Het is ontworpen om elke commit (niet alleen de laatste) op dezelfde manier te bewerken als commit --amend
$ git rebase-reword 
Het is genoemd naar de actie op rebase interactive om een ​​commit te wijzigen: "reword". Zie dit bericht en man -sectie interactieve modus-
Voorbeelden:
$ git rebase-reword b68f560
$ git rebase-reword HEAD ^
|
Ik heb de aliassen reci en recm toegevoegd om het opnieuw te bevestigen (wijzigen). Nu kan ik het doen met git recm of git recm -m:
$ vim ~ / .gitconfig
[alias]
......
cm = vastleggen
reci = commit --amend
recm = commit --amend
......
|
Ik realiseerde me dat ik een commit had gepusht met een typefout erin. Om het ongedaan te maken, deed ik het volgende:
git commit --amend -m "T-1000, geavanceerd prototype"
git push --force
Waarschuwing: het forceren van uw wijzigingen zal de remote branch overschrijven met uw lokale. Zorg ervoor dat u niets overschrijft dat u wilt behouden. Wees ook voorzichtig met het geforceerd pushen van een gewijzigde (herschreven) commit als iemand anders de branch met je deelt, omdat ze hun eigen geschiedenis moeten herschrijven als ze de oude kopie hebben van de commit die je zojuist hebt herschreven.
|
Ik gebruik graag het volgende:
git status
git add --all
git commit -am "bericht komt hier over de wijziging"
git pull 
git push 
|
Als je de code niet naar je remote branch (GitHub / Bitbucket) hebt gepusht, kun je het vastlegbericht op de opdrachtregel wijzigen zoals hieronder.
git commit --amend -m "Je nieuwe bericht"
Als je aan een specifieke branch werkt, doe dit dan:
git commit --amend -m "BRANCH-NAME: nieuw bericht"
Als je de code al met het verkeerde bericht hebt gepusht, en je moet voorzichtig zijn bij het wijzigen van het bericht. Dat wil zeggen, nadat je het vastlegbericht hebt gewijzigd en het opnieuw hebt geprobeerd te pushen, krijg je problemen. Volg deze stappen om het soepel te laten verlopen.
Lees alstublieft mijn volledige antwoord voordat u het doet.
git commit --amend -m "BRANCH-NAME: je nieuwe bericht"
git push -f origin BRANCH-NAME # Geen best practice. Lees hieronder waarom?
Belangrijke opmerking: als je de force push direct gebruikt, zou je kunnen eindigen met codeproblemen die andere ontwikkelaars aan dezelfde branch werken. Dus om die conflicten te vermijden, moet je de code uit je branch halen voordat je de force uitvoertDuwen:
git commit --amend -m "BRANCH-NAME: je nieuwe bericht"
git pull origin BRANCH-NAME
git push -f oorsprong BRANCH-NAME
Dit is de beste praktijk bij het wijzigen van het vastlegbericht, als het al gepusht was.
|
Niet het antwoord waar je naar zoekt? Blader door andere vragen met de tag git git-commit git-rewrite-history wijzig of stel je eigen vraag.